Impara C in 10 minuti
C è un potente linguaggio di programmazione generico noto per la sua efficienza e capacità di lavorare a basso livello con l’hardware. Questo tutorial copre i fondamenti della programmazione C, aiutandoti a comprendere rapidamente il linguaggio.
1. Scrivere il tuo primo programma in C
Iniziamo con il classico programma “Hello, World!”. Crea un file chiamato hello.c
e inserisci il seguente codice:
#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}
Salva il file e compilalo usando un compilatore C come GCC:
gcc hello.c -o hello
./hello
L’output sarà:
Hello, World!
Questo semplice programma dimostra la struttura di base di C:
#include <stdio.h>
include la libreria standard di input/outputint main()
è il punto di ingresso del programmaprintf()
mostra l’output di testoreturn 0
indica l’esecuzione riuscita
2. Sintassi di base
C utilizza una sintassi strutturata con punti e virgola per terminare le istruzioni e parentesi graffe {}
per definire blocchi di codice.
// Questo è un commento su una riga
/* Questo è un commento su più righe */
#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}
Regole di sintassi di base in C:
- Punti e virgola: Ogni istruzione deve terminare con un punto e virgola
;
- Commenti: I commenti su una riga usano
//
, i commenti su più righe usano/* */
- Blocchi di codice: Definiti da parentesi graffe
{}
- Differenza maiuscole/minuscole: C è case-sensitive (
main
vsMain
)
3. Variabili e tipi di dati
C è un linguaggio tipizzato staticamente, il che significa che devi dichiarare i tipi delle variabili prima dell’uso.
Regole di base per la denominazione delle variabili:
- I nomi delle variabili possono contenere lettere, numeri e underscore
- I nomi delle variabili non possono iniziare con un numero
- I nomi delle variabili sono case-sensitive
- Le parole chiave di C non possono essere usate come nomi di variabili
Principali tipi di dati in C:
- int: Numeri interi (es.
42
,-10
) - float: Numeri in virgola mobile (es.
3.14
,-2.5
) - double: Numeri in virgola mobile a doppia precisione
- char: Caratteri singoli (es.
'A'
,'z'
) - void: Nessun tipo
int age = 25;
float temperature = 36.5;
double pi = 3.14159265359;
char grade = 'A';
3.1 Tipi interi
C fornisce diversi tipi interi con dimensioni diverse:
char small_number = 100; // Di solito 1 byte
short medium_number = 32000; // Di solito 2 bytes
int regular_number = 1000000; // Di solito 4 bytes
long large_number = 1000000000; // Di solito 4 o 8 bytes
3.2 Tipi in virgola mobile
float single_precision = 3.14f;
double double_precision = 3.14159265359;
long double extended_precision = 3.14159265358979323846L;
3.3 Tipo carattere
I caratteri sono memorizzati come interi usando la codifica ASCII:
char letter = 'A';
char digit = '7';
char newline = '\n';
char tab = '\t';
4. Costanti
Le costanti sono valori fissi che non possono essere modificati durante l’esecuzione del programma:
const int MAX_SIZE = 100;
const float PI = 3.14159;
const char NEWLINE = '\n';
#define MAX_USERS 1000
#define PI 3.14159
5. Input e output
C utilizza funzioni da stdio.h
per le operazioni di input e output.
5.1 Output con printf()
#include <stdio.h>
int main() {
int age = 25;
float height = 1.75;
char name[] = "John";
printf("Hello, %s!\n", name);
printf("You are %d years old\n", age);
printf("Your height is %.2f meters\n", height);
return 0;
}
Specificatori di formato comuni:
%d
- intero%f
- float/double%c
- carattere%s
- stringa%p
- puntatore
5.2 Input con scanf()
#include <stdio.h>
int main() {
int age;
float height;
char name[50];
printf("Enter your name: ");
scanf("%s", name);
printf("Enter your age: ");
scanf("%d", &age);
printf("Enter your height: ");
scanf("%f", &height);
printf("Hello %s, you are %d years old and %.2f meters tall\n",
name, age, height);
return 0;
}
6. Operatori
C fornisce un ricco set di operatori per varie computazioni.
6.1 Operatori aritmetici
int a = 10, b = 3;
printf("Addition: %d\n", a + b); // 13
printf("Subtraction: %d\n", a - b); // 7
printf("Multiplication: %d\n", a * b); // 30
printf("Division: %d\n", a / b); // 3
printf("Modulus: %d\n", a % b); // 1
6.2 Operatori di confronto
int x = 5, y = 10;
printf("Equal: %d\n", x == y); // 0 (false)
printf("Not equal: %d\n", x != y); // 1 (true)
printf("Greater than: %d\n", x > y); // 0
printf("Less than: %d\n", x < y); // 1
6.3 Operatori logici
int a = 1, b = 0;
printf("AND: %d\n", a && b); // 0
printf("OR: %d\n", a || b); // 1
printf("NOT: %d\n", !a); // 0
6.4 Operatori bitwise
unsigned int a = 5; // 0101 in binario
unsigned int b = 3; // 0011 in binario
printf("AND: %d\n", a & b); // 1 (0001)
printf("OR: %d\n", a | b); // 7 (0111)
printf("XOR: %d\n", a ^ b); // 6 (0110)
printf("NOT: %d\n", ~a); // dipende dal sistema
printf("Left shift: %d\n", a << 1); // 10 (1010)
printf("Right shift: %d\n", a >> 1); // 2 (0010)
7. Controllo del flusso
C fornisce diverse istruzioni di controllo del flusso per gestire l’esecuzione del programma.
7.1 Istruzioni if
int age = 20;
if (age >= 18) {
printf("Adult\n");
} else if (age >= 13) {
printf("Teen\n");
} else {
printf("Child\n");
}
7.2 Istruzioni switch
int day = 3;
switch (day) {
case 1:
printf("Monday\n");
break;
case 2:
printf("Tuesday\n");
break;
case 3:
printf("Wednesday\n");
break;
default:
printf("Other day\n");
}
7.3 Cicli for
for (int i = 0; i < 5; i++) {
printf("i = %d\n", i);
}
7.4 Cicli while
int count = 0;
while (count < 5) {
printf("Count: %d\n", count);
count++;
}
7.5 Cicli do-while
int count = 0;
do {
printf("Count: %d\n", count);
count++;
} while (count < 5);
7.6 break e continue
for (int i = 0; i < 10; i++) {
if (i == 5) {
break; // Esce dal ciclo
}
if (i % 2 == 0) {
continue; // Salta i numeri pari
}
printf("i = %d\n", i); // Output: 1, 3
}
8. Array
Gli array memorizzano più valori dello stesso tipo.
8.1 Array unidimensionali
int numbers[5] = {1, 2, 3, 4, 5};
// Accesso agli elementi
printf("First element: %d\n", numbers[0]);
printf("Last element: %d\n", numbers[4]);
// Modifica degli elementi
numbers[0] = 10;
// Ciclo attraverso l'array
for (int i = 0; i < 5; i++) {
printf("numbers[%d] = %d\n", i, numbers[i]);
}
8.2 Array multidimensionali
int matrix[2][3] = {
{1, 2, 3},
{4, 5, 6}
};
// Accesso agli elementi
printf("matrix[1][2] = %d\n", matrix[1][2]); // 6
// Ciclo attraverso array 2D
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
printf("%d ", matrix[i][j]);
}
printf("\n");
}
9. Stringhe
In C, le stringhe sono array di caratteri terminati da un carattere nullo \0
.
char greeting[] = "Hello"; // Include automaticamente il terminatore nullo
char name[20] = "John";
// Funzioni per le stringhe da string.h
#include <string.h>
char str1[20] = "Hello";
char str2[20] = "World";
printf("Length: %lu\n", strlen(str1)); // 5
strcpy(str1, str2); // Copia str2 in str1
printf("After copy: %s\n", str1); // World
if (strcmp(str1, str2) == 0) {
printf("Strings are equal\n");
}
10. Funzioni
Le funzioni sono blocchi di codice riutilizzabili che eseguono compiti specifici.
10.1 Definizione e chiamata di funzioni
#include <stdio.h>
// Dichiarazione della funzione
int add(int a, int b);
int main() {
int result = add(5, 3);
printf("5 + 3 = %d\n", result);
return 0;
}
// Definizione della funzione
int add(int a, int b) {
return a + b;
}
10.2 Funzione senza valore di ritorno
void greet(char name[]) {
printf("Hello, %s!\n", name);
}
int main() {
greet("Alice");
return 0;
}
10.3 Funzioni ricorsive
int factorial(int n) {
if (n <= 1) {
return 1;
}
return n * factorial(n - 1);
}
int main() {
printf("5! = %d\n", factorial(5)); // 120
return 0;
}
11. Puntatori
I puntatori sono variabili che memorizzano indirizzi di memoria.
11.1 Uso base dei puntatori
int number = 42;
int *ptr = &number; // ptr memorizza l'indirizzo di number
printf("Value: %d\n", number); // 42
printf("Address: %p\n", &number); // Indirizzo di memoria
printf("Pointer value: %d\n", *ptr); // 42 (dereferenziazione)
// Modifica del valore attraverso il puntatore
*ptr = 100;
printf("New value: %d\n", number); // 100
11.2 Puntatori e array
int numbers[] = {1, 2, 3, 4, 5};
int *ptr = numbers; // punta al primo elemento
printf("First element: %d\n", *ptr); // 1
printf("Second element: %d\n", *(ptr + 1)); // 2
// Il nome dell'array è essenzialmente un puntatore al primo elemento
for (int i = 0; i < 5; i++) {
printf("numbers[%d] = %d\n", i, *(numbers + i));
}
11.3 Puntatori e funzioni
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
int main() {
int x = 5, y = 10;
printf("Before swap: x=%d, y=%d\n", x, y);
swap(&x, &y);
printf("After swap: x=%d, y=%d\n", x, y);
return 0;
}
12. Strutture
Le strutture ti permettono di raggruppare variabili correlate insieme.
12.1 Definizione e uso delle strutture
#include <stdio.h>
#include <string.h>
// Definizione della struttura
struct Student {
char name[50];
int age;
float gpa;
};
int main() {
// Creazione di variabili struttura
struct Student student1;
// Assegnazione di valori
strcpy(student1.name, "Alice");
student1.age = 20;
student1.gpa = 3.8;
// Accesso ai membri della struttura
printf("Name: %s\n", student1.name);
printf("Age: %d\n", student1.age);
printf("GPA: %.2f\n", student1.gpa);
return 0;
}
12.2 Strutture con puntatori
struct Point {
int x;
int y;
};
int main() {
struct Point p1 = {10, 20};
struct Point *ptr = &p1;
printf("Coordinates: (%d, %d)\n", ptr->x, ptr->y);
return 0;
}
13. Allocazione dinamica della memoria
C fornisce funzioni per la gestione dinamica della memoria.
13.1 malloc, calloc, realloc, free
#include <stdio.h>
#include <stdlib.h>
int main() {
// Alloca memoria per 5 interi
int *numbers = (int*)malloc(5 * sizeof(int));
if (numbers == NULL) {
printf("Memory allocation failed!\n");
return 1;
}
// Inizializza l'array
for (int i = 0; i < 5; i++) {
numbers[i] = i * 10;
}
// Stampa l'array
for (int i = 0; i < 5; i++) {
printf("numbers[%d] = %d\n", i, numbers[i]);
}
// Libera la memoria allocata
free(numbers);
return 0;
}
13.2 Allocazione dinamica di stringhe
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
char *name = (char*)malloc(50 * sizeof(char));
if (name != NULL) {
strcpy(name, "Dynamic string");
printf("Name: %s\n", name);
free(name);
}
return 0;
}
14. Operazioni sui file
C fornisce funzioni per leggere da e scrivere su file.
14.1 Scrittura su un file
#include <stdio.h>
int main() {
FILE *file = fopen("example.txt", "w");
if (file == NULL) {
printf("Error opening file!\n");
return 1;
}
fprintf(file, "Hello, File!\n");
fprintf(file, "This is a test.\n");
fclose(file);
printf("File written successfully.\n");
return 0;
}
14.2 Lettura da un file
#include <stdio.h>
int main() {
FILE *file = fopen("example.txt", "r");
if (file == NULL) {
printf("Error opening file!\n");
return 1;
}
char buffer[100];
while (fgets(buffer, sizeof(buffer), file) != NULL) {
printf("%s", buffer);
}
fclose(file);
return 0;
}
15. Direttive del preprocessore
Le direttive del preprocessore vengono elaborate prima della compilazione.
15.1 #include
#include <stdio.h> // File di intestazione di sistema
#include "myheader.h" // File di intestazione utente
15.2 #define
#define PI 3.14159
#define MAX(a, b) ((a) > (b) ? (a) : (b))
int main() {
double area = PI * 5 * 5;
int larger = MAX(10, 20);
printf("Area: %.2f\n", area);
printf("Larger number: %d\n", larger);
return 0;
}
15.3 Compilazione condizionale
#define DEBUG 1
int main() {
#ifdef DEBUG
printf("Debug mode enabled\n");
#endif
#if DEBUG == 1
printf("Debug level 1\n");
#elif DEBUG == 2
printf("Debug level 2\n");
#else
printf("No debug\n");
#endif
return 0;
}
16. Gestione degli errori
C non ha una gestione delle eccezioni integrata, quindi usiamo valori di ritorno e codici di errore.
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main() {
FILE *file = fopen("nonexistent.txt", "r");
if (file == NULL) {
printf("Error opening file: %s\n", strerror(errno));
return 1;
}
fclose(file);
return 0;
}
Questo tutorial completo di C copre i concetti essenziali che ti servono per iniziare a programmare in C. Pratica questi esempi ed esplora argomenti più avanzati come liste concatenate, puntatori a funzioni e programmi multi-file man mano che acquisisci maggiore familiarità con il linguaggio.